
/*
    Software License

    Copyright (C) 2021-05-24  Xoronos

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, version 3.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

/*
    Liabilities

    The software is provided "AS IS" without any warranty of any kind, either expressed,
    implied, or statutory, including, but not limited to, any warranty that the software
    will conform to specifications, any implied warranties of merchantability, fitness
    for a particular purpose, and freedom from infringement, and any warranty that the
    documentation will conform to the software, or any warranty that the software will
    be error free.

    In no event shall Xoronos be liable for any damages, including, but not limited to,
    direct, indirect, special or consequential damages, arising out of, resulting from,
    or in any way connected with this software, whether or not based upon warranty,
    contract, tort, or otherwise, whether or not injury was sustained by persons or
    property or otherwise, and whether or not loss was sustained from, or arose out of
    the results of, or use of, the software or services provided hereunder.

    To request the provided software under a different license you can contact us at
    support@xoronos.com
*/

#include "lexexample.h"
#include "lexcheck.h"

void lex_print_suggestions( int current_command, char *all_args[]
 )
{
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\na valid example could be:\n\n" );
    XLEX_PRINT(  );
    lexexamples_all( current_command, 0, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\nto know all the options for the current command, you can type:\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s ", all_args[XH_HELP] );
    XLEX_PRINT(  );
    lex_print_stripped_command( current_command, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n\nto get a random example, you can type:\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s -rnd ", all_args[XE_EXAMPLE] );
    XLEX_PRINT(  );
    lex_print_stripped_command( current_command, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\n\nto know how to use the command within a script, you can type:\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s ", all_args[XS_SCRIPT] );
    XLEX_PRINT(  );
    lex_print_stripped_command( current_command, all_args );
    snprintf
        ( lexer_log.buffer, BUFF_PRINT_SIZE,
          "\n\nfor support and general info you can contact us at:\n\nsupport@xoronos.com\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_print_general_structure( char *all_args[]
 )
{

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE,
              "\nThe general structure of the command is shown below.\n\n" );
    XLEX_PRINT(  );
    lex_print_original_command(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s -options \\\n", all_args[XDC_DECODING_CONF] );
    XLEX_PRINT(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s -options \\\n", all_args[XEC_ENCODING_CONF] );
    XLEX_PRINT(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s -options \\\n", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s -options \\\n", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s -options \\\n", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s -options \\\n", all_args[XLC_LOGGING_CONF] );
    XLEX_PRINT(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "--command -options \n" );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\nTo know the list of commands, you can run:\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s \n", all_args[XH_HELP] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s \n", all_args[XE_EXAMPLE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s \n", all_args[XS_SCRIPT] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\nTo know more about a command, you can run:\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s command \n", all_args[XH_HELP] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s command \n", all_args[XE_EXAMPLE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s command \n", all_args[XS_SCRIPT] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\nFor randomized examples, you can run: \n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s -rnd command \n", all_args[XE_EXAMPLE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s -rnd command \n", all_args[XS_SCRIPT] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\nTo know the version, you can run:\n\n" );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xrnlib-cli %s \n\n", all_args[XV_VERSION] );
    XLEX_PRINT(  );

}

void lex_example_encoding_conf( int rnd, int neutral_standard_alice_bob, int dump_encoding_param,
                                char *all_args[]
 )
{

    int rnd_var, rnd_var2;
    time_t t;
    int no_param;

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_ENCODING_CONF] );
    XLEX_PRINT(  );

    no_param = 0;

    if ( rnd == 0 ) {
        if ( neutral_standard_alice_bob == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_COMPILED_PARAM] );
            XLEX_PRINT(  );
        } else if ( neutral_standard_alice_bob == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_ENCODING_PARAM] );
            XLEX_PRINT(  );
            lex_print_path_option( XEC_ENCODING_PARAM, neutral_standard_alice_bob, all_args );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_NO_PASSWORD] );
            XLEX_PRINT(  );
        } else if ( neutral_standard_alice_bob == 2 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_ENCODING_PARAM] );
            XLEX_PRINT(  );
            lex_print_path_option( XEC_ENCODING_PARAM, neutral_standard_alice_bob, all_args );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_NO_PASSWORD] );
            XLEX_PRINT(  );
        } else if ( neutral_standard_alice_bob == 3 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_ENCODING_PARAM] );
            XLEX_PRINT(  );
            lex_print_path_option( XEC_ENCODING_PARAM, neutral_standard_alice_bob, all_args );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_NO_PASSWORD] );
            XLEX_PRINT(  );
        }

    } else {

        srand( ( unsigned ) time( &t ) );
        rnd_var = rand(  );
        no_param = 0;
        if ( dump_encoding_param == 1 ) {
            if ( ( rnd_var % 2 ) == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_COMPILED_PARAM] );
                XLEX_PRINT(  );
            } else {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_ENCODING_PARAM] );
                XLEX_PRINT(  );
                lex_print_path_option( XEC_ENCODING_PARAM, neutral_standard_alice_bob, all_args );
            }

        } else {
            if ( ( rnd_var % 3 ) == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_COMPILED_PARAM] );
                XLEX_PRINT(  );
            } else if ( ( rnd_var % 3 ) == 1 ) {
                no_param = 1;
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_NO_PARAM] );
                XLEX_PRINT(  );
            } else {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_ENCODING_PARAM] );
                XLEX_PRINT(  );
                lex_print_path_option( XEC_ENCODING_PARAM, neutral_standard_alice_bob, all_args );
            }

        }

        rnd_var = rand(  );

        if ( dump_encoding_param == 1 ) {
            if ( ( rnd_var % 2 ) == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_PASSWORD_STR] );
                XLEX_PRINT(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\"Password123#\" " );
                XLEX_PRINT(  );
            } else {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_INIT_FILE] );
                XLEX_PRINT(  );
                lex_print_path_option( XEC_INIT_FILE, neutral_standard_alice_bob, all_args );
            }

        } else {
            if ( ( rnd_var % 4 ) == 0 ) {
                if ( no_param == 0 ) {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_NO_PASSWORD] );
                    XLEX_PRINT(  );
                }

            } else if ( ( ( rnd_var % 4 ) == 1 ) && ( no_param == 0 ) ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_PASSWORD_STR] );
                XLEX_PRINT(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\"Password123#\" " );
                XLEX_PRINT(  );
            } else if ( ( ( rnd_var % 4 ) == 2 ) && ( no_param == 0 ) ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_INIT_FILE] );
                XLEX_PRINT(  );
                lex_print_path_option( XEC_INIT_FILE, neutral_standard_alice_bob, all_args );
            }

        }

        if ( no_param == 0 ) {

            rnd_var = rand(  );

            if ( ( rnd_var % 2 ) == 0 ) {

                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_NO_RUNNING_ERR] );
                XLEX_PRINT(  );

            } else if ( ( rnd_var % 2 ) == 1 ) {

                rnd_var2 = rand(  );
                if ( rnd_var2 % 2 == 0 ) {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_RUNNING_ERR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "36 " );
                    XLEX_PRINT(  );
                } else {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_RUNNING_ERR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "36 " );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_RUNNING_WAR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "32 " );
                    XLEX_PRINT(  );
                }

            }

            rnd_var = rand(  );

            if ( ( rnd_var % 2 ) == 0 ) {

                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_NO_DISPARITY_ERR] );
                XLEX_PRINT(  );

            } else if ( ( rnd_var % 2 ) == 1 ) {

                rnd_var2 = rand(  );
                if ( rnd_var2 % 2 == 0 ) {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_DISPARITY_ERR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "704 " );
                    XLEX_PRINT(  );
                } else {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_DISPARITY_ERR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "704 " );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_DISPARITY_WAR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "640 " );
                    XLEX_PRINT(  );
                }

            }

        }

    }

    lex_print_end(  );
}

void lex_example_decoding_conf( int rnd, int neutral_standard_alice_bob, char *all_args[]
 )
{

    int rnd_var, rnd_var2;
    time_t t;
    int no_param;

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_DECODING_CONF] );
    XLEX_PRINT(  );

    if ( rnd == 0 ) {
        if ( neutral_standard_alice_bob == 0 ) {

            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_COMPILED_PARAM] );
            XLEX_PRINT(  );

        } else if ( neutral_standard_alice_bob == 1 ) {

            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_ENCODING_PARAM] );
            XLEX_PRINT(  );
            lex_print_path_option( XDC_ENCODING_PARAM, neutral_standard_alice_bob, all_args );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_NO_PASSWORD] );
            XLEX_PRINT(  );

        } else if ( neutral_standard_alice_bob == 2 ) {

            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_ENCODING_PARAM] );
            XLEX_PRINT(  );
            lex_print_path_option( XEC_ENCODING_PARAM, neutral_standard_alice_bob, all_args );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_NO_PASSWORD] );
            XLEX_PRINT(  );

        } else if ( neutral_standard_alice_bob == 3 ) {

            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_ENCODING_PARAM] );
            XLEX_PRINT(  );
            lex_print_path_option( XEC_ENCODING_PARAM, neutral_standard_alice_bob, all_args );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_NO_PASSWORD] );
            XLEX_PRINT(  );

        }

    } else {

        srand( ( unsigned ) time( &t ) );
        rnd_var = rand(  );
        no_param = 0;
        if ( ( rnd_var % 3 ) == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_COMPILED_PARAM] );
            XLEX_PRINT(  );
        } else if ( ( rnd_var % 3 ) == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_NO_PARAM] );
            XLEX_PRINT(  );
            no_param = 1;
        } else {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_ENCODING_PARAM] );
            XLEX_PRINT(  );
            lex_print_path_option( XDC_ENCODING_PARAM, neutral_standard_alice_bob, all_args );
        }

        if ( no_param == 0 ) {

            rnd_var = rand(  );

            if ( ( rnd_var % 4 ) == 0 ) {
                if ( no_param == 0 ) {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_NO_PASSWORD] );
                    XLEX_PRINT(  );
                }

            } else if ( ( ( rnd_var % 4 ) == 1 ) && ( no_param == 0 ) ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_PASSWORD_STR] );
                XLEX_PRINT(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\"Password123#\" " );
                XLEX_PRINT(  );
            } else if ( ( ( rnd_var % 4 ) == 2 ) && ( no_param == 0 ) ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_INIT_FILE] );
                XLEX_PRINT(  );
                lex_print_path_option( XDC_INIT_FILE, neutral_standard_alice_bob, all_args );
            }

            rnd_var = rand(  );
            if ( ( rnd_var % 2 ) == 0 ) {

                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_NO_RUNNING_ERR] );
                XLEX_PRINT(  );

            } else if ( ( rnd_var % 2 ) == 1 ) {

                rnd_var2 = rand(  );
                if ( rnd_var2 % 2 == 0 ) {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_RUNNING_ERR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "36 " );
                    XLEX_PRINT(  );
                } else {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_RUNNING_ERR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "36 " );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_RUNNING_WAR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "32 " );
                    XLEX_PRINT(  );
                }

            }

            rnd_var = rand(  );

            if ( ( rnd_var % 2 ) == 0 ) {

                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_NO_DISPARITY_ERR] );
                XLEX_PRINT(  );

            } else if ( ( rnd_var % 2 ) == 1 ) {

                rnd_var2 = rand(  );
                if ( rnd_var2 % 2 == 0 ) {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_DISPARITY_ERR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "704 " );
                    XLEX_PRINT(  );
                } else {
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_DISPARITY_ERR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "704 " );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDC_DISPARITY_WAR_TH] );
                    XLEX_PRINT(  );
                    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "640 " );
                    XLEX_PRINT(  );
                }

            }

        }

    }

    lex_print_end(  );
}

void lex_example_logging_conf( int rnd, int response, int neutral_standard_alice_bob, char *all_args[]
 )
{

    int rnd_var, logging_started, rnd_var2;
    time_t t;

    logging_started = 0;

    if ( response == 1 ) {
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_LOGGING_CONF] );
        XLEX_PRINT(  );

        if ( rnd != 0 ) {
            srand( ( unsigned ) time( &t ) );

            rnd_var = rand(  );
            if ( ( rnd_var % 3 ) == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_FORCE_APPEND] );
                XLEX_PRINT(  );
            } else if ( ( rnd_var % 3 ) == 1 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_FORCE_WRITE] );
                XLEX_PRINT(  );
            }

        }

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_LIB_INFO_LOG] );
        XLEX_PRINT(  );
        if ( neutral_standard_alice_bob == 0 ) {
            lex_print_path_option( XLC_LIB_INFO_LOG, neutral_standard_alice_bob, all_args );
        } else if ( neutral_standard_alice_bob == 1 ) {

            rnd_var = lex_print_example_get_random_number(  );
            if ( rnd_var != XRNL_ERROR ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sinfo_log_%u.json ", LEXER_EXAMPLES_DUMP_DIR,
                          ( uint32_t ) rnd_var );
                XLEX_PRINT(  );
            }

        } else if ( neutral_standard_alice_bob == 2 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%salice_info_log.json ", LEXER_EXAMPLES_DUMP_DIR );
            XLEX_PRINT(  );
        } else if ( neutral_standard_alice_bob == 3 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sbob_info_log.json ", LEXER_EXAMPLES_DUMP_DIR );
            XLEX_PRINT(  );
        }

        logging_started = 1;
    }

    if ( rnd != 0 ) {

        srand( ( unsigned ) time( &t ) );

        if ( logging_started != 1 ) {
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_LOGGING_CONF] );
            XLEX_PRINT(  );
            logging_started = 1;

            srand( ( unsigned ) time( &t ) );

            rnd_var = rand(  );
            if ( ( rnd_var % 3 ) == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_FORCE_APPEND] );
                XLEX_PRINT(  );
            } else if ( ( rnd_var % 3 ) == 1 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_FORCE_WRITE] );
                XLEX_PRINT(  );
            }

        }

        rnd_var = rand(  );
        if ( ( rnd_var % 2 ) == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_NO_COMMAND_LINE_LOG] );
            XLEX_PRINT(  );
        } else {
            rnd_var2 = rand(  );
            if ( rnd_var2 % 2 == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_COMMAND_LINE_LOG] );
                XLEX_PRINT(  );
                lex_print_path_option( XLC_COMMAND_LINE_LOG, neutral_standard_alice_bob, all_args );
            }

        }

        rnd_var = rand(  );
        if ( ( rnd_var % 2 ) == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_NO_LIB_ERROR_LOG] );
            XLEX_PRINT(  );
        } else {
            rnd_var2 = rand(  );
            if ( rnd_var2 % 2 == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_LIB_ERROR_LOG] );
                XLEX_PRINT(  );
                lex_print_path_option( XLC_LIB_ERROR_LOG, neutral_standard_alice_bob, all_args );
            }

        }

        rnd_var = rand(  );
        if ( ( rnd_var % 2 ) == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_NO_LIB_WARNING_LOG] );
            XLEX_PRINT(  );
        } else {
            rnd_var2 = rand(  );
            if ( rnd_var2 % 2 == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_LIB_WARNING_LOG] );
                XLEX_PRINT(  );
                lex_print_path_option( XLC_LIB_WARNING_LOG, neutral_standard_alice_bob, all_args );
            }

        }

        rnd_var = rand(  );
        if ( ( rnd_var % 2 ) == 0 ) {

            rnd_var2 = rand(  );
            if ( rnd_var2 % 2 == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XLC_LIB_DEBUG_LOG] );
                XLEX_PRINT(  );
                lex_print_path_option( XLC_LIB_DEBUG_LOG, neutral_standard_alice_bob, all_args );
            }

            rnd_var2 = rand(  );
            if ( rnd_var2 % 2 == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %d ", all_args[XLC_DEBUG_SEED],
                          rnd_var2 % 65536 );
                XLEX_PRINT(  );
            }

        }

    }

    if ( logging_started ) {
        lex_print_end(  );
    }

}

void lex_example_dump_encoding_param( int rnd, int arch, int force_perm,
                                      int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    if ( neutral_standard_alice_bob == 0 ) {

        lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 1, all_args );

    } else if ( neutral_standard_alice_bob == 1 ) {

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_ENCODING_CONF] );
        XLEX_PRINT(  );

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_COMPILED_PARAM] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"Password123#\" ", all_args[XEC_PASSWORD_STR] );
        XLEX_PRINT(  );

        lex_print_end(  );

    } else if ( neutral_standard_alice_bob == 2 ) {

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_ENCODING_CONF] );
        XLEX_PRINT(  );

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_COMPILED_PARAM] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"AlicePassword0#\" ", all_args[XEC_PASSWORD_STR] );
        XLEX_PRINT(  );

        lex_print_end(  );

    } else if ( neutral_standard_alice_bob == 3 ) {

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_ENCODING_CONF] );
        XLEX_PRINT(  );

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_COMPILED_PARAM] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"BobPassword0#\" ", all_args[XEC_PASSWORD_STR] );
        XLEX_PRINT(  );

        lex_print_end(  );

    }

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDEP_DUMP_ENCODING_PARAM] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDEP_ENCODING_PARAM] );
    XLEX_PRINT(  );
    lex_print_path_option( XDEP_ENCODING_PARAM, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );
}

void lex_example_decode_encode( int rnd, int arch, int force_perm,
                                int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response;

    response = 0;
    if ( neutral_standard_alice_bob == 0 ) {

        lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
        lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
        lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_DECODE_ENCODE] );
        XLEX_PRINT(  );

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_TO_DECODE] );
        XLEX_PRINT(  );
        lex_print_path_option( XDE_TO_DECODE, neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_TO_ENCODE] );
        XLEX_PRINT(  );
        lex_print_path_option( XDE_TO_ENCODE, neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );

    } else if ( neutral_standard_alice_bob == 1 ) {

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s ", all_args[XDC_DECODING_CONF],
                  all_args[XDC_NO_PARAM] );
        XLEX_PRINT(  );
        lex_print_end(  );

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s ", all_args[XEC_ENCODING_CONF],
                  all_args[XEC_ENCODING_PARAM] );
        XLEX_PRINT(  );
        lex_print_path_option( XEC_ENCODING_PARAM, 0, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_NO_PASSWORD] );
        XLEX_PRINT(  );
        lex_print_end(  );

        lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_DECODE_ENCODE] );
        XLEX_PRINT(  );

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_TO_DECODE] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "plain_text.txt " );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_TO_ENCODE] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "encoded_file.xf " );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );

    } else if ( neutral_standard_alice_bob == 4 ) {

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s ", all_args[XDC_DECODING_CONF],
                  all_args[XDC_ENCODING_PARAM] );
        XLEX_PRINT(  );
        lex_print_path_option( XDC_ENCODING_PARAM, 0, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEC_NO_PASSWORD] );
        XLEX_PRINT(  );
        lex_print_end(  );

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %s ", all_args[XEC_ENCODING_CONF],
                  all_args[XEC_NO_PARAM] );
        XLEX_PRINT(  );
        lex_print_end(  );

        lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_DECODE_ENCODE] );
        XLEX_PRINT(  );

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_TO_DECODE] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "encoded_file.xf " );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_TO_ENCODE] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "decoded_file.txt " );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );

    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_TO_DECODE] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "encoded_file.xf " );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDE_TO_ENCODE] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "decoded_file.txt " );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_example_mine_xmatrix_comp_rand( int rnd, int arch, int force_perm, int force_pseudo_random,
                                         int neutral_standard_alice_bob, char *all_args[]
 )
{

    int rnd_var, response;
    time_t t;

    response = 0;

    if ( rnd == 0 ) {
        if ( force_pseudo_random == 0 ) {
            lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
            XLEX_PRINT(  );
            lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );
            lex_print_end(  );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_MINE_XMATRIX_COMP_RND] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_RANDOM] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_XMATRIX_COMP] );
            XLEX_PRINT(  );
        } else {
            lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
            lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_POINT] );
            XLEX_PRINT(  );
            lex_print_path_option( XAC_POINT, neutral_standard_alice_bob, all_args );
            lex_print_end(  );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
            XLEX_PRINT(  );
            lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );
            lex_print_end(  );
            lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_MINE_XMATRIX_COMP_RND] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_PSEUDO_RANDOM] );
            XLEX_PRINT(  );
        }

        lex_print_path_option( XMXCR_XMATRIX_COMP, neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );

    } else {                    // random
        srand( ( unsigned ) time( &t ) );
        rnd_var = rand(  );
        if ( ( rnd_var % 2 == 0 ) && ( force_pseudo_random == 0 ) ) {
            lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
            XLEX_PRINT(  );
            lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );
            lex_print_end(  );
            lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_MINE_XMATRIX_COMP_RND] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_RANDOM] );
            XLEX_PRINT(  );
        } else {                // force pseudo random
            lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
            lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_POINT] );
            XLEX_PRINT(  );
            lex_print_path_option( XAC_POINT, neutral_standard_alice_bob, all_args );
            lex_print_end(  );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
            XLEX_PRINT(  );
            lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );
            lex_print_end(  );
            lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_MINE_XMATRIX_COMP_RND] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_PSEUDO_RANDOM] );
            XLEX_PRINT(  );

            rnd_var = rand(  );
            if ( rnd_var % 2 == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_PROB_ONES] );
                XLEX_PRINT(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "0.005 " );
                XLEX_PRINT(  );
            }

            rnd_var = rand(  );
            if ( rnd_var % 2 == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_MAX_TRIES] );
                XLEX_PRINT(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "50000 " );
                XLEX_PRINT(  );
            }

        }

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCR_XMATRIX_COMP] );
        XLEX_PRINT(  );
        lex_print_path_option( XMXCR_XMATRIX_COMP, neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_example_mine_xmatrix_comp_ot( int rnd, int arch, int force_perm, int force_pseudo_random,
                                       int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;
    int rnd_var;
    time_t t;

    response = 0;

    if ( rnd == 0 ) {
        lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
        XLEX_PRINT(  );
        lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );
        lex_print_end(  );
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_MINE_XMATRIX_COMP_OT] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_RANDOM] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_XMATRIX_COMP] );
        XLEX_PRINT(  );
        lex_print_path_option( XMXCO_XMATRIX_COMP, neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    } else {
        srand( ( unsigned ) time( &t ) );
        rnd_var = rand(  );
        if ( ( rnd_var % 2 == 0 ) && ( force_pseudo_random == 0 ) ) {
            lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
            XLEX_PRINT(  );
            lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );
            lex_print_end(  );
            lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_MINE_XMATRIX_COMP_OT] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_RANDOM] );
            XLEX_PRINT(  );
        } else {
            lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
            lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_POINT] );
            XLEX_PRINT(  );
            lex_print_path_option( XAC_POINT, neutral_standard_alice_bob, all_args );
            lex_print_end(  );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
            XLEX_PRINT(  );
            lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );
            lex_print_end(  );
            lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_MINE_XMATRIX_COMP_OT] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_PSEUDO_RANDOM] );
            XLEX_PRINT(  );

            rnd_var = rand(  );
            if ( rnd_var % 2 == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_MAX_ONES_PER_ROW] );
                XLEX_PRINT(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "5 " );
                XLEX_PRINT(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_MIN_ONES_PER_ROW] );
                XLEX_PRINT(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "2 " );
                XLEX_PRINT(  );
            }

            rnd_var = rand(  );
            if ( rnd_var % 2 == 0 ) {
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_MAX_TRIES] );
                XLEX_PRINT(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "50000 " );
                XLEX_PRINT(  );
            }

        }

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMXCO_XMATRIX_COMP] );
        XLEX_PRINT(  );
        lex_print_path_option( XMXCO_XMATRIX_COMP, neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    }

}

void lex_example_permute_xmatrix_comp_random( int rnd, int arch, int force_perm,
                                              int neutral_standard_alice_bob,
                                              int neutral_personality, char *all_args[]
 )
{
    int response;
    int rnd_var;
    time_t t;

    srand( ( unsigned ) time( &t ) );
    rnd_var = rand(  );
    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
        lex_print_end(  );
    }

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX_COMP] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX_COMP, neutral_standard_alice_bob, all_args );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );
    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );
    lex_print_end(  );
    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPXCR_PERMUTE_XMATRIX_COMP_RANDOM] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPXCR_XMATRIX_COMP_DST] );
    XLEX_PRINT(  );
    if ( neutral_personality == 0 ) {
        lex_print_path_option( XPXCR_XMATRIX_COMP_DST, neutral_standard_alice_bob, all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xmatrix_comp_rnd_perm.xf " );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_permute_xmatrix_comp_deterministic( int rnd, int arch, int force_perm,
                                                     int neutral_standard_alice_bob,
                                                     int neutral_personality, char *all_args[]
 )
{
    int response;
    time_t t;

    response = 0;

    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX_COMP] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX_COMP, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );
    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );
    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPXCD_XMATRIX_COMP_DST] );
    XLEX_PRINT(  );
    if ( neutral_personality == 0 ) {
        lex_print_path_option( XPXCD_XMATRIX_COMP_DST, neutral_standard_alice_bob, all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xmatrix_comp_det_perm.xf " );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_permute_xmatrix_comp_confidential( int rnd, int arch, int force_perm,
                                                    int neutral_standard_alice_bob,
                                                    int neutral_personality, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX_COMP] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX_COMP, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );
    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPXCS_XMATRIX_COMP_DST] );
    XLEX_PRINT(  );
    if ( neutral_personality == 0 ) {
        lex_print_path_option( XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL, neutral_standard_alice_bob,
                               all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "xmatrix_comp_sec_perm.xf " );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_decompress_xmatrix( int rnd, int arch, int force_perm,
                                     int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX_COMP] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX_COMP, neutral_standard_alice_bob, all_args );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );
    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDX_DECOMPRESS_XMATRIX] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDX_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XDX_XMATRIX, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_xmatrix_comp( int rnd, int arch, int force_perm,
                                     int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 1;
    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX_COMP] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX_COMP, neutral_standard_alice_bob, all_args );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );
    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCXC_CHECK_XMATRIX_COMP] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_xmatrix( int rnd, int arch, int force_perm,
                                int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 1;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );
    lex_print_end(  );
    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );
    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCX_CHECK_XMATRIX] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_point( int rnd, int arch, int force_perm, int neutral_standard_alice_bob,
                             char *all_args[]
 )
{
    int rnd_var;
    int response;

    time_t t;

    srand( ( unsigned ) time( &t ) );
    rnd_var = rand(  );
    response = 0;

    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
        lex_print_end(  );
    }

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMP_MAKE_POINT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMP_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMP_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_confidential_pseudo_random_number( int rnd, int arch, int force_perm,
                                                         int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XMSPRN_MAKE_CONFIDENTIAL_PSEUDO_RANDOM_NUMBER] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSPRN_NEXT_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSPRN_NEXT_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_start_point( int rnd, int arch, int force_perm,
                                   int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var, response;
    time_t t;

    srand( ( unsigned ) time( &t ) );
    rnd_var = rand(  );
    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
        lex_print_end(  );
    }

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSP_MAKE_START_POINT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSP_START_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSP_START_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_monomial_key( int rnd, int arch, int force_perm,
                                    int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var, response;
    time_t t;

    response = 0;

    srand( ( unsigned ) time( &t ) );
    rnd_var = rand(  );

    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
        lex_print_end(  );
    }

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMK_MAKE_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMK_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMK_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_binomial_key( int rnd, int arch, int force_perm,
                                    int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_START_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_START_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMBK_MAKE_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMBK_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMBK_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_exchange_monomial_key( int rnd, int arch, int force_perm,
                                        int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );

    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEMK_EXCHANGE_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEMK_EXTERNAL_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob < 2 ) {
        lex_print_path_option( XEMK_EXTERNAL_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sbob_binomial_key_for_alice.xf ",
                  LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEMK_SHARED_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XEMK_SHARED_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_monovalent_key( int rnd, int arch, int force_perm,
                                      int neutral_standard_alice_bob, char *all_args[]
 )
{

    int rnd_var, rnd_var2, response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );
    rnd_var = rand(  );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        lex_print_start(  );

        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
        XLEX_PRINT(  );
        rnd_var2 = rand(  );
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        } else {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                      all_args[XAC_RND_STR] );
            XLEX_PRINT(  );
        }

        lex_print_end(  );
    }

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMK_MAKE_MONOVALENT_KEY] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMK_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMK_MONOVALENT_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMK_POLYVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMK_POLYVALENT_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMK_POLYVALENT_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMK_POLYVALENT_PROOF, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %lu ", all_args[XMMK_START_TIMESTAMP], ( uint64_t ) t );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %lu ", all_args[XMMK_END_TIMESTAMP],
              ( uint64_t ) ( t + 600 ) );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_exchange_polyvalent_key( int rnd, int arch, int force_perm,
                                          int neutral_standard_alice_bob, char *all_args[]
 )
{

    int rnd_var2, response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOVALENT_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_POLYVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_POLYVALENT_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_POLYVALENT_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_POLYVALENT_PROOF, neutral_standard_alice_bob, all_args );

    if ( rnd != 0 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEPK_EXCHANGE_POLYVALENT_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEPK_EXTERNAL_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob < 2 ) {
        lex_print_path_option( XEPK_EXTERNAL_MONOVALENT_KEY, neutral_standard_alice_bob, all_args );
    } else if ( neutral_standard_alice_bob == 2 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sbob_monovalent_key.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    } else if ( neutral_standard_alice_bob == 3 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%salice_monovalent_key.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEPK_SHARED_POLYVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XEPK_SHARED_POLYVALENT_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_monovalent_key( int rnd, int arch, int force_perm,
                                       int neutral_standard_alice_bob, char *all_args[]
 )
{

    int rnd_var2;
    time_t t;
    int response;

    response = 1;

    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOVALENT_KEY] );
    XLEX_PRINT(  );

    if ( neutral_standard_alice_bob < 2 ) {
        lex_print_path_option( XAC_MONOVALENT_KEY, neutral_standard_alice_bob, all_args );
    } else if ( neutral_standard_alice_bob == 2 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sbob_monovalent_key.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    } else if ( neutral_standard_alice_bob == 3 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%salice_monovalent_key.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_POLYVALENT_PROOF] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob < 2 ) {
        lex_print_path_option( XAC_POLYVALENT_PROOF, neutral_standard_alice_bob, all_args );
    } else if ( neutral_standard_alice_bob == 2 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sbob_polyvalent_proof.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    } else if ( neutral_standard_alice_bob == 3 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%salice_polyvalent_proof.xf ",
                  LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    if ( rnd != 0 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCMK_CHECK_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_commitment_binomial_key( int rnd, int arch, int force_perm,
                                               int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var, response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCBK_MAKE_COMMITMENT_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCBK_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCBK_MONOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCBK_BINOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCBK_BINOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_commitment_sym_signature( int rnd, int arch, int force_perm,
                                                int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var, response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_SIGNATURE, neutral_standard_alice_bob, all_args );

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCSS_MAKE_COMMITMENT_SYM_SIGNATURE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCSS_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSS_MONOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCSS_BINOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSS_BINOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSS_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_commitment_sym_certificate( int rnd, int arch, int force_perm,
                                                  int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var, response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_CERTIFICATE, neutral_standard_alice_bob, all_args );

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCSC_MAKE_COMMITMENT_SYM_CERTIFICATE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCSC_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSC_MONOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCSC_BINOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCSC_BINOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_response( int rnd, int arch, int force_perm,
                                int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var, response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );
    rnd_var = rand(  );

    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
        lex_print_end(  );
    }

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMR_MAKE_RESPONSE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMR_MONOMIAL_RESPONSE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMR_MONOMIAL_RESPONSE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_monomial_proof( int rnd, int arch, int force_perm,
                                      int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_RESPONSE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_RESPONSE, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMP_MAKE_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMP_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMP_MONOMIAL_PROOF, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_monomial_proof_sym_signature( int rnd, int arch, int force_perm,
                                                    int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response;
    int rnd_var;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_SIGNATURE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_RESPONSE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_RESPONSE, neutral_standard_alice_bob, all_args );
    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
        XLEX_PRINT(  );
    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMPSS_MAKE_MONOMIAL_PROOF_SYM_SIGNATURE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMPSS_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMPSS_MONOMIAL_PROOF, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMPSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMPSS_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_monomial_proof_sym_certificate( int rnd, int arch, int force_perm,
                                                      int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var;
    int response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_CERTIFICATE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_RESPONSE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_RESPONSE, neutral_standard_alice_bob, all_args );
    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
        XLEX_PRINT(  );
    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XMMPSC_MAKE_MONOMIAL_PROOF_SYM_CERTIFICATE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMMPSC_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XMMPSC_MONOMIAL_PROOF, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_monovalent_proof( int rnd, int arch, int force_perm,
                                         int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 1;
    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_RESPONSE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_RESPONSE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_PROOF, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCMP_CHECK_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_monovalent_proof_sym_signature( int rnd, int arch, int force_perm,
                                                       int neutral_standard_alice_bob, char *all_args[]
 )
{

    int rnd_var2;
    int response;
    time_t t;

    response = 1;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_SIGNATURE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_RESPONSE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_RESPONSE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_PROOF, neutral_standard_alice_bob, all_args );

    rnd_var2 = rand(  );
    if ( rnd_var2 % 3 == 0 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
        XLEX_PRINT(  );
    } else if ( rnd_var2 % 3 == 1 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
        XLEX_PRINT(  );
    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCMPSS_CHECK_MONOMIAL_PROOF_SYM_SIGNATURE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCMPSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCMPSS_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_monovalent_proof_sym_certificate( int rnd, int arch, int force_perm,
                                                         int neutral_standard_alice_bob, char *all_args[]
 )
{

    int rnd_var2;
    time_t t;
    int response;

    response = 1;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_CERTIFICATE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_RESPONSE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_RESPONSE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_PROOF] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_PROOF, neutral_standard_alice_bob, all_args );

    rnd_var2 = rand(  );
    if ( rnd != 0 ) {
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCMPSC_CHECK_MONOMIAL_PROOF_SYM_CERTIFICATE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_signature_symmetric( int rnd, int arch, int force_perm,
                                           int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var2, rnd_var, response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 4 ", all_args[XAC_STATE_SIZE] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
    }

    rnd_var2 = rand(  );
    if ( rnd != 0 ) {
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSS_MAKE_SIGNATURE_SYMMETRIC] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSS_PLAIN_TEXT, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSS_SYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSS_SYMMETRIC_SIGNATURE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_signature_asymmetric( int rnd, int arch, int force_perm,
                                            int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var2, response, rnd_var;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 4 ", all_args[XAC_STATE_SIZE] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
    }

    rnd_var2 = rand(  );
    if ( rnd != 0 ) {
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSA_MAKE_SIGNATURE_ASYMMETRIC] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSA_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSA_PLAIN_TEXT, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSA_ASYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSA_ASYMMETRIC_SIGNATURE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_permute_ring_signature( int rnd, int arch, int force_perm,
                                         int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPRS_PERMUTE_RING_SIGNATURE] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPRS_SIGNER_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_SIGNER_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPRS_VERIFIER_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_VERIFIER_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPRS_SIGNER_RING_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_SIGNER_RING_SIGNATURE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPRS_VERIFIER_RING_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_VERIFIER_RING_SIGNATURE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPRS_PERMUTED_RING_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XPRS_PERMUTED_RING_SIGNATURE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_ring_signature( int rnd, int arch, int force_perm,
                                      int neutral_standard_alice_bob, char *all_args[]
 )
{

    int i;
    int response;
    int rnd_var2, rnd_var;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 4 ", all_args[XAC_STATE_SIZE] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
    }

    rnd_var2 = rand(  );
    if ( rnd != 0 ) {
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMRS_MAKE_RING_SIGNATURE] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMRS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMRS_PLAIN_TEXT, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMRS_VERIFIER_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMRS_VERIFIER_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMRS_RING_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMRS_RING_SIGNATURE, neutral_standard_alice_bob, all_args );

    for ( i = 0; i < 3; i++ ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMRS_ADD_DECOY_BINOMIAL_KEY] );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s_%d.xf ", "decoy_binomial_key", i );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_certificate_symmetric( int rnd, int arch, int force_perm,
                                             int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response, rnd_var2, rnd_var;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 4 ", all_args[XAC_STATE_SIZE] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
    }

    rnd_var2 = rand(  );
    if ( rnd != 0 ) {
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCS_MAKE_CERTIFICATE_SYMMETRIC] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCS_SUBJECT_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCS_SUBJECT_MONOVALENT_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"Alice monovalent key\" ", all_args[XMCS_SUBJECT_STR] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCS_SYMMETRIC_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCS_SYMMETRIC_CERTIFICATE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %lu ", all_args[XMCS_START_TIMESTAMP], ( uint64_t ) t );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %lu ", all_args[XMCS_END_TIMESTAMP],
              ( uint64_t ) ( t + 600 ) );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_certificate_asymmetric( int rnd, int arch, int force_perm,
                                              int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response, rnd_var2, rnd_var;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 4 ", all_args[XAC_STATE_SIZE] );
        XLEX_PRINT(  );
    }

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"$(echo $RANDOM | base64)\" ",
                  all_args[XAC_RND_STR] );
        XLEX_PRINT(  );
    }

    rnd_var2 = rand(  );
    if ( rnd != 0 ) {
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCA_MAKE_CERTIFICATE_ASYMMETRIC] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCA_SUBJECT_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCA_SUBJECT_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s \"Alice binomial key\" ", all_args[XMCA_SUBJECT_STR] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMCA_ASYMMETRIC_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMCA_ASYMMETRIC_CERTIFICATE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %lu ", all_args[XMCA_START_TIMESTAMP], ( uint64_t ) t );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %lu ", all_args[XMCA_END_TIMESTAMP],
              ( uint64_t ) ( t + 600 ) );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_signature_symmetric( int rnd, int arch, int force_perm,
                                            int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response, rnd_var2;
    time_t t;

    response = 1;

    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_SIGNATURE, neutral_standard_alice_bob, all_args );

    if ( rnd != 0 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCSS_CHECK_SIGNATURE_SYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCSS_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_signature_asymmetric( int rnd, int arch, int force_perm,
                                             int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response, rnd_var2;
    time_t t;

    response = 1;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ASY_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_ASY_SIGNATURE, neutral_standard_alice_bob, all_args );

    if ( rnd != 0 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCSA_CHECK_SIGNATURE_ASYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCSA_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCSA_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_ring_signature( int rnd, int arch, int force_perm,
                                       int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response, rnd_var2;
    time_t t;

    response = 1;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob == 0 ) {
        lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sverifier_monomial_key.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_RING_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_RING_SIGNATURE, neutral_standard_alice_bob, all_args );

    if ( rnd != 0 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCRS_CHECK_RING_SIGNATURE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCRS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCRS_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCRS_SIGNER_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCRS_SIGNER_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_certificate_symmetric( int rnd, int arch, int force_perm,
                                              int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response, rnd_var2;
    time_t t;

    response = 1;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_CERTIFICATE, neutral_standard_alice_bob, all_args );

    if ( rnd != 0 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCCS_CHECK_CERTIFICATE_SYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_certificate_asymmetric( int rnd, int arch, int force_perm,
                                               int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response, rnd_var2;
    time_t t;

    response = 1;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ASY_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_ASY_CERTIFICATE, neutral_standard_alice_bob, all_args );

    if ( rnd != 0 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCCA_CHECK_CERTIFICATE_ASYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_hash( int rnd, int arch, int force_perm, int neutral_standard_alice_bob,
                            char *all_args[]
 )
{

    int response, rnd_var;
    int arithmetic_layer_defined;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    if ( rnd != 0 ) {
        arithmetic_layer_defined = 0;
        rnd_var = rand(  );
        if ( rnd_var % 3 == 0 ) {
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
            arithmetic_layer_defined = 1;
        } else if ( rnd_var % 3 == 1 ) {
            lex_print_start(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
            XLEX_PRINT(  );
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
            arithmetic_layer_defined = 1;
        }

        rnd_var = rand(  );
        if ( rnd_var % 2 == 0 ) {
            if ( arithmetic_layer_defined == 0 ) {
                lex_print_start(  );
                snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
                XLEX_PRINT(  );
                arithmetic_layer_defined = 1;
            }

            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 4 ", all_args[XAC_STATE_SIZE] );
            XLEX_PRINT(  );
        }

        if ( arithmetic_layer_defined == 1 ) {
            lex_print_end(  );
        }

    }

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMH_MAKE_HASH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMH_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMH_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMH_HASH] );
    XLEX_PRINT(  );
    lex_print_path_option( XMH_HASH, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_hash( int rnd, int arch, int force_perm, int neutral_standard_alice_bob,
                             char *all_args[]
 )
{

    int response, rnd_var2;
    time_t t;

    response = 1;
    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_HASH] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_HASH, neutral_standard_alice_bob, all_args );
    if ( rnd != 0 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 3 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_CONST_EXEC_TIME] );
            XLEX_PRINT(  );
        } else if ( rnd_var2 % 3 == 1 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_NO_THREAD] );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCH_CHECK_HASH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCH_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCH_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_checksum( int rnd, int arch, int force_perm,
                                int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMC_MAKE_CHECKSUM] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMC_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMC_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMC_CHECKSUM_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMC_CHECKSUM_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_checksum( int rnd, int arch, int force_perm,
                                 int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 1;

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCC_CHECK_CHECKSUM] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCC_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCC_PLAIN_TEXT, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCC_CHECKSUM_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCC_CHECKSUM_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_hash_to_monomial_key( int rnd, int arch, int force_perm,
                                               int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_HASH] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_HASH, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCHTMK_CONVERT_HASH_TO_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCHTMK_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCHTMK_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_hash_to_point( int rnd, int arch, int force_perm,
                                        int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_HASH] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_HASH, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCHTP_CONVERT_HASH_TO_POINT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCHTP_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCHTP_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_point_to_monomial_key( int rnd, int arch, int force_perm,
                                                int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response;
    time_t t;

    response = 0;

    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_POINT, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCPTMK_CONVERT_POINT_TO_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCPTMK_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCPTMK_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_monomial_key_to_point( int rnd, int arch, int force_perm,
                                                int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCMKTP_CONVERT_MONOMIAL_KEY_TO_POINT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCMKTP_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCMKTP_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_binomial_key_to_start_point( int rnd, int arch, int force_perm,
                                                      int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob == 3 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%salice_binomial_key_for_bob.xf ",
                  LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    } else {
        lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCBKTSP_CONVERT_BINOMIAL_KEY_TO_START_POINT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCBKTSP_START_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCBKTSP_START_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_start_point_to_point( int rnd, int arch, int force_perm,
                                               int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_START_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_START_POINT, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCSPTP_CONVERT_START_POINT_TO_POINT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCSPTP_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCSPTP_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_point_to_start_point( int rnd, int arch, int force_perm,
                                               int neutral_standard_alice_bob, char *all_args[]
 )
{

    time_t t;
    int response;

    response = 0;

    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_POINT, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCPTSP_CONVERT_POINT_TO_START_POINT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCPTSP_START_POINT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCPTSP_START_POINT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_monomial_key_to_monomial_commitment( int rnd, int arch, int force_perm,
                                                              int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCMKTMC_CONVERT_MONOMIAL_KEY_TO_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCMKTMC_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XCMKTMC_MONOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_monomial_commitment_to_monomial_key( int rnd, int arch, int force_perm,
                                                              int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_COMMITMENT] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_COMMITMENT, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCMCTMK_CONVERT_MONOMIAL_COMMITMENT_TO_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCMCTMK_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCMCTMK_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_asymmetric_certificate_to_binomial_key( int rnd, int arch, int force_perm,
                                                                 int neutral_standard_alice_bob,
                                                                 char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ASY_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_ASY_CERTIFICATE, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCACTBK_CONVERT_ASYMMETRIC_CERTIFICATE_TO_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCACTBK_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob != 1 ) {
        lex_print_path_option( XCACTBK_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sextracted_binomial_key.xf ",
                  LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_asymmetric_signature_to_binomial_key( int rnd, int arch, int force_perm,
                                                               int neutral_standard_alice_bob,
                                                               char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ASY_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_ASY_SIGNATURE, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCASTBK_CONVERT_ASYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCASTBK_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob != 1 ) {
        lex_print_path_option( XCASTBK_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sbinomial_key.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_symmetric_signature_to_binomial_key( int rnd, int arch, int force_perm,
                                                              int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_SIGNATURE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_SIGNATURE, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCSSTBK_CONVERT_SYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCSSTBK_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob != 1 ) {
        lex_print_path_option( XCSSTBK_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sbinomial_key.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_binomial_key_to_asymmetric_signature( int rnd, int arch, int force_perm,
                                                               int neutral_standard_alice_bob,
                                                               char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCBKTAS_CONVERT_BINOMIAL_KEY_TO_ASYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCBKTAS_ASYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob != 1 ) {
        lex_print_path_option( XCBKTAS_ASYMMETRIC_SIGNATURE, neutral_standard_alice_bob, all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sasymmetric_signature.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_binomial_key_to_symmetric_signature( int rnd, int arch, int force_perm,
                                                              int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCBKTSS_CONVERT_BINOMIAL_KEY_TO_SYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCBKTSS_SYMMETRIC_SIGNATURE] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob != 1 ) {
        lex_print_path_option( XCBKTSS_SYMMETRIC_SIGNATURE, neutral_standard_alice_bob, all_args );
    } else {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%ssymmetric_signature.xf ", LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_convert_symmetric_certificate_to_monovalent_key( int rnd, int arch, int force_perm,
                                                                  int neutral_standard_alice_bob,
                                                                  char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_SYM_CERTIFICATE] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_SYM_CERTIFICATE, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ",
              all_args[XCSCTMK_CONVERT_SYMMETRIC_CERTIFICATE_TO_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCSCTMK_MONOVALENT_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XCSCTMK_MONOVALENT_KEY, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_split_symmetric( int rnd, int arch, int force_perm,
                                  int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var2, rnd_var;
    time_t t;
    int response;

    response = 0;

    srand( ( unsigned ) time( &t ) );

    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        lex_print_start(  );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
        XLEX_PRINT(  );
        rnd_var2 = rand(  );
        if ( ( rnd_var2 % 3 == 0 ) && ( rnd != 0 ) ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 4 ", all_args[XAC_STATE_SIZE] );
            XLEX_PRINT(  );
        } else if ( ( rnd_var2 % 3 == 1 ) && ( rnd != 0 ) ) {
            rnd_var = rand(  );
            if ( rnd_var % 4 == 0 ) {
                rnd_var = 8;
            } else if ( rnd_var % 4 == 1 ) {
                rnd_var = 16;
            } else if ( rnd_var % 4 == 2 ) {
                rnd_var = 32;
            } else if ( rnd_var % 4 == 3 ) {
                rnd_var = 64;
            }

            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %d ", all_args[XAC_CRC_BITS], rnd_var );
            XLEX_PRINT(  );
        }

        lex_print_end(  );
    }

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSS_SPLIT_SYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSS_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSS_SOLUTION_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSS_SOLUTION_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSS_CHALLENGE_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XSS_CHALLENGE_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_join_symmetric( int rnd, int arch, int force_perm,
                                 int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XJS_JOIN_SYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XJS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sdeciphered_plain_text.txt ", LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XJS_SOLUTION_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XJS_SOLUTION_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XJS_CHALLENGE_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XJS_CHALLENGE_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_encrypt_symmetric( int rnd, int arch, int force_perm,
                                    int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var2, rnd_var;
    time_t t;
    int response;

    response = 0;

    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        rnd_var2 = rand(  );
        if ( ( rnd_var2 % 2 == 0 ) && ( rnd != 0 ) ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 4 ", all_args[XAC_STATE_SIZE] );
            XLEX_PRINT(  );
        }

        rnd_var2 = rand(  );
        if ( ( rnd_var2 % 2 == 0 ) && ( rnd != 0 ) ) {
            rnd_var = rand(  );
            if ( rnd_var % 4 == 0 ) {
                rnd_var = 8;
            } else if ( rnd_var % 4 == 1 ) {
                rnd_var = 16;
            } else if ( rnd_var % 4 == 2 ) {
                rnd_var = 32;
            } else if ( rnd_var % 4 == 3 ) {
                rnd_var = 64;
            }

            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %d ", all_args[XAC_CRC_BITS], rnd_var );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XES_ENCRYPT_SYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XES_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XES_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XES_CIPHER_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XES_CIPHER_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_encrypt_asymmetric( int rnd, int arch, int force_perm,
                                     int neutral_standard_alice_bob, char *all_args[]
 )
{
    int rnd_var2, rnd_var;
    time_t t;
    int response;

    response = 0;

    srand( ( unsigned ) time( &t ) );

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );
    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_BINOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_BINOMIAL_KEY, neutral_standard_alice_bob, all_args );
    rnd_var = rand(  );
    if ( ( rnd_var % 2 == 0 ) && ( rnd != 0 ) ) {
        rnd_var2 = rand(  );
        if ( ( rnd_var2 % 2 == 0 ) && ( rnd != 0 ) ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 4 ", all_args[XAC_STATE_SIZE] );
            XLEX_PRINT(  );
        }

        rnd_var2 = rand(  );
        if ( ( rnd_var2 % 2 == 0 ) && ( rnd != 0 ) ) {
            rnd_var = rand(  );
            if ( rnd_var % 4 == 0 ) {
                rnd_var = 8;
            } else if ( rnd_var % 4 == 1 ) {
                rnd_var = 16;
            } else if ( rnd_var % 4 == 2 ) {
                rnd_var = 32;
            } else if ( rnd_var % 4 == 3 ) {
                rnd_var = 64;
            }

            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %d ", all_args[XAC_CRC_BITS], rnd_var );
            XLEX_PRINT(  );
        }

    }

    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEA_ENCRYPT_ASYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEA_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XEA_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XEA_CIPHER_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XEA_CIPHER_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_decipher_asymmetric( int rnd, int arch, int force_perm,
                                      int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDA_DECIPHER_ASYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDA_PLAIN_TEXT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sdeciphered_plain_text.txt ", LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDA_CIPHER_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XDA_CIPHER_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_decipher_symmetric( int rnd, int arch, int force_perm,
                                     int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_ARITHMETIC_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XAC_MONOMIAL_KEY] );
    XLEX_PRINT(  );
    lex_print_path_option( XAC_MONOMIAL_KEY, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_SEQUENCE_CONF] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSC_XMATRIX] );
    XLEX_PRINT(  );
    lex_print_path_option( XSC_XMATRIX, neutral_standard_alice_bob, all_args );
    lex_print_end(  );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDS_DECIPHER_SYMMETRIC] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDS_PLAIN_TEXT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sdeciphered_plain_text.txt ", LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XDS_CIPHER_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XDS_CIPHER_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_check_complete_blocks( int rnd, int arch, int force_perm,
                                        int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response;

    response = 1;

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCCB_CHECK_COMPLETE_BLOCK] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCCB_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XCCB_BLOCK_FILE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_block( int rnd, int arch, int force_perm, int neutral_standard_alice_bob,
                             char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMB_MAKE_BLOCK] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 0 ", all_args[XMB_OFFSET] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 32 ", all_args[XMB_LENGTH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 0 ", all_args[XMB_TAG] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMB_PLAIN_TEXT] );
    XLEX_PRINT(  );
    lex_print_path_option( XMB_PLAIN_TEXT, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMB_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMB_BLOCK_FILE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_merge_block( int rnd, int arch, int force_perm,
                              int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response;

    response = 0;

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCB_COMBINE_BLOCKS] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %sfirst_block.xf ", all_args[XCB_BLOCK_FILE],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %ssecond_block.xf ", all_args[XCB_BLOCK_FILE],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s %sthird_block.xf ", all_args[XCB_BLOCK_FILE],
              LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XCB_COMBINED_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XCB_COMBINED_BLOCK_FILE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_strip_header_from_block( int rnd, int arch, int force_perm,
                                          int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSHFB_STRIP_HEADER_FROM_BLOCK] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSHFB_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XSHFB_BLOCK_FILE, neutral_standard_alice_bob, all_args );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XSHFB_PLAIN_TEXT] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%sstripped_plain_text.txt ", LEXER_EXAMPLES_DUMP_DIR );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_print_header( int rnd, int arch, int force_perm,
                               int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 1;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPC_PERMUTATION_CONF] );
    XLEX_PRINT(  );

    lex_print_example_arch( rnd, arch, neutral_standard_alice_bob, all_args );

    lex_print_end(  );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPH_PRINT_HEADER] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPH_XRN_FILE] );
    XLEX_PRINT(  );
    if ( neutral_standard_alice_bob < 3 ) {
        lex_print_path_option( XPH_XRN_FILE, neutral_standard_alice_bob, all_args );
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
        XLEX_PRINT(  );
    } else if ( neutral_standard_alice_bob == 3 ) {
        snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%salice_monovalent_key_for_bob.xf\n",
                  LEXER_EXAMPLES_DUMP_DIR );
        XLEX_PRINT(  );
    }

}

void lex_example_print_lib_info( int rnd, int arch, int force_perm,
                                 int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response;

    response = 1;

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XPLI_PRINT_LIB_INFO] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_get_capacity( int rnd, int arch, int force_perm,
                               int neutral_standard_alice_bob, char *all_args[]
 )
{
    int response;
    int rnd_var2;
    time_t t;

    response = 1;
    srand( ( unsigned ) time( &t ) );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XGC_GET_CAPACITY] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XGC_ENVELOP_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XGC_ENVELOP_FILE, neutral_standard_alice_bob, all_args );

    if ( rnd == 1 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 2 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XGC_DISABLE_FOLDING] );
            XLEX_PRINT(  );
        }

    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_steganography_raw( int rnd, int arch, int force_perm, int neutral_standard_alice_bob,
                                         char *all_args[]
 )
{

    int response;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSR_MAKE_STEGANOGRAPHY_RAW] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSR_SOURCE_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSR_SOURCE_FILE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSR_ENVELOP_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSR_ENVELOP_FILE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSR_EMBEDDED_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSR_EMBEDDED_FILE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_make_steganography_block( int rnd, int arch, int force_perm, int neutral_standard_alice_bob,
                                           char *all_args[]
 )
{

    int response;
    int rnd_var2;
    time_t t;

    response = 0;
    srand( ( unsigned ) time( &t ) );

    lex_example_encoding_conf( rnd, neutral_standard_alice_bob, 0, all_args );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSB_MAKE_STEGANOGRAPHY_BLOCK] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 0 ", all_args[XMSB_OFFSET] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 32 ", all_args[XMSB_LENGTH] );
    XLEX_PRINT(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s 0 ", all_args[XMSB_TAG] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSB_SOURCE_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSB_SOURCE_FILE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSB_ENVELOP_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSB_ENVELOP_FILE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSB_EMBEDDED_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XMSB_EMBEDDED_FILE, neutral_standard_alice_bob, all_args );

    if ( rnd == 1 ) {
        rnd_var2 = rand(  );
        if ( rnd_var2 % 2 == 0 ) {
            snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XMSB_DISABLE_FOLDING] );
            XLEX_PRINT(  );
        }

    }

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_extract_steganography_raw( int rnd, int arch, int force_perm,
                                            int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XESR_EXTRACT_STEGANOGRAPHY_RAW] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XESR_EMBEDDED_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XESB_EMBEDDED_FILE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XESR_RAW_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XESB_BLOCK_FILE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lex_example_extract_steganography_block( int rnd, int arch, int force_perm,
                                              int neutral_standard_alice_bob, char *all_args[]
 )
{

    int response;

    response = 0;

    lex_example_decoding_conf( rnd, neutral_standard_alice_bob, all_args );

    lex_example_logging_conf( rnd, response, neutral_standard_alice_bob, all_args );

    lex_print_start(  );
    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XESB_EXTRACT_STEGANOGRAPHY_BLOCK] );
    XLEX_PRINT(  );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XESB_EMBEDDED_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XESB_EMBEDDED_FILE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "%s ", all_args[XESB_BLOCK_FILE] );
    XLEX_PRINT(  );
    lex_print_path_option( XESB_BLOCK_FILE, neutral_standard_alice_bob, all_args );

    snprintf( lexer_log.buffer, BUFF_PRINT_SIZE, "\n" );
    XLEX_PRINT(  );

}

void lexexamples_all( int command, int rnd, char *all_args[]
 )
{

    int arch, force_perm;
    int force_pseudo_random;
    int neutral_personality;
    int neutral_standard_alice_bob;

    lex_print_original_command(  );

    arch = 256;
    force_perm = 0;
    force_pseudo_random = 0;
    neutral_standard_alice_bob = 0;
    neutral_personality = 0;

    if ( command == XDC_DECODING_CONF ) {
    } else if ( command == XEC_ENCODING_CONF ) {
    } else if ( command == XAC_ARITHMETIC_CONF ) {
    } else if ( command == XSC_SEQUENCE_CONF ) {
    } else if ( command == XPC_PERMUTATION_CONF ) {
    } else if ( command == XLC_LOGGING_CONF ) {
    } else if ( command == XDEP_DUMP_ENCODING_PARAM ) {
        lex_example_dump_encoding_param( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XDE_DECODE_ENCODE ) {
        lex_example_decode_encode( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMXCR_MINE_XMATRIX_COMP_RND ) {
        lex_example_mine_xmatrix_comp_rand( rnd, arch, force_perm, force_pseudo_random,
                                            neutral_standard_alice_bob, all_args );
    } else if ( command == XMXCO_MINE_XMATRIX_COMP_OT ) {
        lex_example_mine_xmatrix_comp_ot( rnd, arch, force_perm, force_pseudo_random,
                                          neutral_standard_alice_bob, all_args );
    } else if ( command == XPXCR_PERMUTE_XMATRIX_COMP_RANDOM ) {
        lex_example_permute_xmatrix_comp_random( rnd, arch, force_perm,
                                                 neutral_standard_alice_bob, neutral_personality, all_args );
    } else if ( command == XPXCD_PERMUTE_XMATRIX_COMP_DETERMINISTIC ) {
        lex_example_permute_xmatrix_comp_deterministic( rnd, arch, force_perm,
                                                        neutral_standard_alice_bob, neutral_personality,
                                                        all_args );
    } else if ( command == XPXCS_PERMUTE_XMATRIX_COMP_CONFIDENTIAL ) {
        lex_example_permute_xmatrix_comp_confidential( rnd, arch, force_perm,
                                                       neutral_standard_alice_bob, neutral_personality,
                                                       all_args );
    } else if ( command == XDX_DECOMPRESS_XMATRIX ) {
        lex_example_decompress_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCXC_CHECK_XMATRIX_COMP ) {
        lex_example_check_xmatrix_comp( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCX_CHECK_XMATRIX ) {
        lex_example_check_xmatrix( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMP_MAKE_POINT ) {
        lex_example_make_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMSPRN_MAKE_CONFIDENTIAL_PSEUDO_RANDOM_NUMBER ) {
        lex_example_make_confidential_pseudo_random_number( rnd, arch, force_perm,
                                                            neutral_standard_alice_bob, all_args );
    } else if ( command == XMSP_MAKE_START_POINT ) {
        lex_example_make_start_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMMK_MAKE_MONOMIAL_KEY ) {
        lex_example_make_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMBK_MAKE_BINOMIAL_KEY ) {
        lex_example_make_binomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XEMK_EXCHANGE_MONOMIAL_KEY ) {
        lex_example_exchange_monomial_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMMK_MAKE_MONOVALENT_KEY ) {
        lex_example_make_monovalent_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XEPK_EXCHANGE_POLYVALENT_KEY ) {
        lex_example_exchange_polyvalent_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCMK_CHECK_MONOVALENT_KEY ) {
        lex_example_check_monovalent_key( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMCBK_MAKE_COMMITMENT_BINOMIAL_KEY ) {
        lex_example_make_commitment_binomial_key( rnd, arch, force_perm,
                                                  neutral_standard_alice_bob, all_args );
    } else if ( command == XMCSS_MAKE_COMMITMENT_SYM_SIGNATURE ) {
        lex_example_make_commitment_sym_signature( rnd, arch, force_perm,
                                                   neutral_standard_alice_bob, all_args );
    } else if ( command == XMCSC_MAKE_COMMITMENT_SYM_CERTIFICATE ) {
        lex_example_make_commitment_sym_certificate( rnd, arch, force_perm,
                                                     neutral_standard_alice_bob, all_args );
    } else if ( command == XMR_MAKE_RESPONSE ) {
        lex_example_make_response( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMMP_MAKE_MONOMIAL_PROOF ) {
        lex_example_make_monomial_proof( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMMPSS_MAKE_MONOMIAL_PROOF_SYM_SIGNATURE ) {
        lex_example_make_monomial_proof_sym_signature( rnd, arch, force_perm,
                                                       neutral_standard_alice_bob, all_args );
    } else if ( command == XMMPSC_MAKE_MONOMIAL_PROOF_SYM_CERTIFICATE ) {
        lex_example_make_monomial_proof_sym_certificate( rnd, arch, force_perm,
                                                         neutral_standard_alice_bob, all_args );
    } else if ( command == XCMP_CHECK_MONOMIAL_PROOF ) {
        lex_example_check_monovalent_proof( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCMPSS_CHECK_MONOMIAL_PROOF_SYM_SIGNATURE ) {
        lex_example_check_monovalent_proof_sym_signature( rnd, arch, force_perm,
                                                          neutral_standard_alice_bob, all_args );
    } else if ( command == XCMPSC_CHECK_MONOMIAL_PROOF_SYM_CERTIFICATE ) {
        lex_example_check_monovalent_proof_sym_certificate( rnd, arch, force_perm,
                                                            neutral_standard_alice_bob, all_args );
    } else if ( command == XMSS_MAKE_SIGNATURE_SYMMETRIC ) {
        lex_example_make_signature_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMSA_MAKE_SIGNATURE_ASYMMETRIC ) {
        lex_example_make_signature_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XPRS_PERMUTE_RING_SIGNATURE ) {
        lex_example_permute_ring_signature( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMRS_MAKE_RING_SIGNATURE ) {
        lex_example_make_ring_signature( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMCS_MAKE_CERTIFICATE_SYMMETRIC ) {
        lex_example_make_certificate_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMCA_MAKE_CERTIFICATE_ASYMMETRIC ) {
        lex_example_make_certificate_asymmetric( rnd, arch, force_perm,
                                                 neutral_standard_alice_bob, all_args );
    } else if ( command == XCSS_CHECK_SIGNATURE_SYMMETRIC ) {
        lex_example_check_signature_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCSA_CHECK_SIGNATURE_ASYMMETRIC ) {
        lex_example_check_signature_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCRS_CHECK_RING_SIGNATURE ) {
        lex_example_check_ring_signature( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCCS_CHECK_CERTIFICATE_SYMMETRIC ) {
        lex_example_check_certificate_symmetric( rnd, arch, force_perm,
                                                 neutral_standard_alice_bob, all_args );
    } else if ( command == XCCA_CHECK_CERTIFICATE_ASYMMETRIC ) {
        lex_example_check_certificate_asymmetric( rnd, arch, force_perm,
                                                  neutral_standard_alice_bob, all_args );
    } else if ( command == XMH_MAKE_HASH ) {
        lex_example_make_hash( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMC_MAKE_CHECKSUM ) {
        lex_example_make_checksum( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCC_CHECK_CHECKSUM ) {
        lex_example_check_checksum( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCH_CHECK_HASH ) {
        lex_example_check_hash( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCHTMK_CONVERT_HASH_TO_MONOMIAL_KEY ) {
        lex_example_convert_hash_to_monomial_key( rnd, arch, force_perm,
                                                  neutral_standard_alice_bob, all_args );
    } else if ( command == XCHTP_CONVERT_HASH_TO_POINT ) {
        lex_example_convert_hash_to_point( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCPTMK_CONVERT_POINT_TO_MONOMIAL_KEY ) {
        lex_example_convert_point_to_monomial_key( rnd, arch, force_perm,
                                                   neutral_standard_alice_bob, all_args );
    } else if ( command == XCMKTP_CONVERT_MONOMIAL_KEY_TO_POINT ) {
        lex_example_convert_monomial_key_to_point( rnd, arch, force_perm,
                                                   neutral_standard_alice_bob, all_args );
    } else if ( command == XCBKTSP_CONVERT_BINOMIAL_KEY_TO_START_POINT ) {
        lex_example_convert_binomial_key_to_start_point( rnd, arch, force_perm,
                                                         neutral_standard_alice_bob, all_args );
    } else if ( command == XCSPTP_CONVERT_START_POINT_TO_POINT ) {
        lex_example_convert_start_point_to_point( rnd, arch, force_perm,
                                                  neutral_standard_alice_bob, all_args );
    } else if ( command == XCPTSP_CONVERT_POINT_TO_START_POINT ) {
        lex_example_convert_point_to_start_point( rnd, arch, force_perm,
                                                  neutral_standard_alice_bob, all_args );
    } else if ( command == XCMKTMC_CONVERT_MONOMIAL_KEY_TO_MONOMIAL_COMMITMENT ) {
        lex_example_convert_monomial_key_to_monomial_commitment( rnd, arch, force_perm,
                                                                 neutral_standard_alice_bob, all_args );
    } else if ( command == XCMCTMK_CONVERT_MONOMIAL_COMMITMENT_TO_MONOMIAL_KEY ) {
        lex_example_convert_monomial_commitment_to_monomial_key( rnd, arch, force_perm,
                                                                 neutral_standard_alice_bob, all_args );
    } else if ( command == XCSCTMK_CONVERT_SYMMETRIC_CERTIFICATE_TO_MONOVALENT_KEY ) {
        lex_example_convert_symmetric_certificate_to_monovalent_key( rnd, arch, force_perm,
                                                                     neutral_standard_alice_bob, all_args );
    } else if ( command == XCACTBK_CONVERT_ASYMMETRIC_CERTIFICATE_TO_BINOMIAL_KEY ) {
        lex_example_convert_asymmetric_certificate_to_binomial_key( rnd, arch, force_perm,
                                                                    neutral_standard_alice_bob, all_args );
    } else if ( command == XCASTBK_CONVERT_ASYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY ) {
        lex_example_convert_asymmetric_signature_to_binomial_key( rnd, arch, force_perm,
                                                                  neutral_standard_alice_bob, all_args );
    } else if ( command == XCSSTBK_CONVERT_SYMMETRIC_SIGNATURE_TO_BINOMIAL_KEY ) {
        lex_example_convert_symmetric_signature_to_binomial_key( rnd, arch, force_perm,
                                                                 neutral_standard_alice_bob, all_args );
    } else if ( command == XCBKTAS_CONVERT_BINOMIAL_KEY_TO_ASYMMETRIC_SIGNATURE ) {
        lex_example_convert_binomial_key_to_asymmetric_signature( rnd, arch, force_perm,
                                                                  neutral_standard_alice_bob, all_args );
    } else if ( command == XCBKTSS_CONVERT_BINOMIAL_KEY_TO_SYMMETRIC_SIGNATURE ) {
        lex_example_convert_binomial_key_to_symmetric_signature( rnd, arch, force_perm,
                                                                 neutral_standard_alice_bob, all_args );
    } else if ( command == XSS_SPLIT_SYMMETRIC ) {
        lex_example_split_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XEA_ENCRYPT_ASYMMETRIC ) {
        lex_example_encrypt_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XES_ENCRYPT_SYMMETRIC ) {
        lex_example_encrypt_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XJS_JOIN_SYMMETRIC ) {
        lex_example_join_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XDA_DECIPHER_ASYMMETRIC ) {
        lex_example_decipher_asymmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XDS_DECIPHER_SYMMETRIC ) {
        lex_example_decipher_symmetric( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCCB_CHECK_COMPLETE_BLOCK ) {
        lex_example_check_complete_blocks( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMB_MAKE_BLOCK ) {
        lex_example_make_block( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XCB_COMBINE_BLOCKS ) {
        lex_example_merge_block( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XSHFB_STRIP_HEADER_FROM_BLOCK ) {
        lex_example_strip_header_from_block( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XPH_PRINT_HEADER ) {
        lex_example_print_header( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XPLI_PRINT_LIB_INFO ) {
        lex_example_print_lib_info( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XGC_GET_CAPACITY ) {
        lex_example_get_capacity( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XMSB_MAKE_STEGANOGRAPHY_BLOCK ) {
        lex_example_make_steganography_block( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XESB_EXTRACT_STEGANOGRAPHY_BLOCK ) {
        lex_example_extract_steganography_block( rnd, arch, force_perm, neutral_standard_alice_bob,
                                                 all_args );
    } else if ( command == XMSR_MAKE_STEGANOGRAPHY_RAW ) {
        lex_example_make_steganography_raw( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    } else if ( command == XESR_EXTRACT_STEGANOGRAPHY_RAW ) {
        lex_example_extract_steganography_raw( rnd, arch, force_perm, neutral_standard_alice_bob, all_args );
    }

}

